class Base1{
    public int a;
    public int b;

    public Base1(int a, int b) {
        this.a = a;
        this.b = b;
    }
    public Base1(){

    }
    //    public int c = 199;
  /*  public void methodBase(){
        System.out.println("Base");
    }*/
    public void methodA(){
        System.out.println("Base中的methodA()");
    }
    public void methodB(){
        System.out.println("Base中的methodB()");
    }
}
class Derived1 extends Base1{
    int a;
    char b;

   public Derived1 (){
       super(1,2);

   }
    /*public Derived1( int a1,char b1,int a, char b) {
        super(a,b);
        this.a = a1;
        this.b = b1;
    }
*/
    public void methodA(int a){
        System.out.println("Derived 中的method()方法");
    }
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
    public void methodC(){
        //对于同名的成员变量，直接访问时，访问的都是子类的
        System.out.println(a = 100);//等价于：this.a = 100
        System.out.println(b = 101);;//等价于：this.b = 101;
      //注意：this是当前对象的引用

      //访问父类的成员变量是，需要借助super关键字
        //super是获取到子类对象中从基类继承下来的部分
        System.out.println(super.a = 200);
        System.out.println(super.b = 201);


      //父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
      methodA() ;//没有传参，访问父类中的methodA()
      methodA(20);//传递int参数，访问子类中的methodA()

        //如果在子类中要访问重写的基类方法，则需要借助super关键字
      methodB();//直接访问，则永远访问到的都是子类中的methodA(),基类的无法访问到
      super.methodB();//访问基类的methodB()
    }
//   public int c = 9;
 /*   public void methodDerived(){
        System.out.println("derived");
    }*/
   /* public void func2(){
        methodBase();
        methodDerived();
    }
   public void func1(){
       //子类有 那么就拿子类的 子类没有 就拿父类的
       System.out.println(a);
       System.out.println(b);
       System.out.println(c);//如果父类和子类有同名的成员变量，就先访问子类自己的
   }*/
}
public class Test {
    public static void main(String[] args) {
        Derived1 derived1 = new Derived1();
//        derived1.func2();
        System.out.println( );
        derived1.methodC();
    }
}
